home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 April: Mac OS SDK / Dev.CD Apr 00 SDK1.toast / Development Kits / Mac OS / Communications Toolbox / CTB Sample Code 1.0b16 / CTB Sources / Sources 2 / Terminal Tool for CTB / tdef.p < prev    next >
Encoding:
Text File  |  1989-06-27  |  19.4 KB  |  717 lines  |  [TEXT/MPS ]
  1. { *** =================================================== ***
  2.  
  3.     Purpose:        Terminal tool main definition code 
  4.         module.  This primitive tool does not perform even
  5.         the most rudimentary functions of the next world-
  6.         class terminal, but provides a simple demonstration
  7.         of discussion between various portions of the
  8.         Communications Toolbox. 
  9.  
  10.     Module :        tdef.p
  11.  
  12.     Authors:        Craig Hotchkiss, Alex Kazim, Byron Han, 
  13.                         Carol Lee
  14.                     Apple Computer, Inc.
  15.                     Networks & Communications
  16.                     20525 Mariani Drive
  17.                     Cupertino, CA 95014
  18.  
  19.     Version :        1.0d1
  20.  
  21.     Date :            9.may.89
  22.  
  23.     History :
  24.         9.may.89    Creation date
  25.  
  26.  
  27.     ©1989 Apple Computer, Inc.  All Rights Reserved.
  28.     This software is proprietary to Apple Computer, Inc.
  29.     It may not be copied, in whole or in part,
  30.     without the written consent of Apple Computer, Inc.
  31.  
  32.   *** =================================================== *** }
  33.     
  34.  
  35.  
  36.  
  37. UNIT TERMINALtdef;
  38.  
  39.  
  40. INTERFACE
  41.  
  42.  
  43. USES     MemTypes,
  44.         QuickDraw,
  45.         OSIntf,
  46.         ToolIntf,
  47.         PasLibIntf,
  48.         Lists,
  49.         CRMSerialIntf,
  50.         CRMIntf,
  51.         CTBUtils,
  52.         CMIntf,
  53.         TMIntf,
  54.         FTIntf,
  55.         TerminalTool,
  56.         TermGlobalUnit;
  57.         
  58.         
  59. FUNCTION tdefMAIN(hTerm: TermHandle; msg: Integer;
  60.     p1, p2, p3: LongInt) : LongInt;
  61.  
  62.  
  63. IMPLEMENTATION
  64.  
  65.  
  66.  
  67. { This block of forward declarations are necessary to introduce 
  68.     this tool's procs and funcs before they are used in tdefMAIN, 
  69.     the main segment of this module. } 
  70. FUNCTION TermToolInit(hTerm: TermHandle): LongInt;
  71.                 FORWARD;
  72. PROCEDURE TermToolDispose(hTerm: TermHandle);
  73.                 FORWARD;
  74. PROCEDURE TermToolSuspend(hTerm: TermHandle);
  75.                 FORWARD;
  76. PROCEDURE TermToolResume(hTerm: TermHandle);
  77.                 FORWARD;
  78. FUNCTION TermToolMenu(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  79.                 FORWARD;
  80. FUNCTION TermToolEvent(hTerm: TermHandle): LongInt;
  81.                 FORWARD;
  82. PROCEDURE TermToolActivate(hTerm: TermHandle);
  83.                 FORWARD;
  84. PROCEDURE TermToolDeactivate(hTerm: TermHandle);
  85.                 FORWARD;
  86. FUNCTION TermToolIdle(hTerm: TermHandle): LongInt;
  87.                 FORWARD;
  88. FUNCTION TermToolReset(hTerm: TermHandle): LongInt;
  89.                 FORWARD;
  90. PROCEDURE TermToolKey(hTerm: TermHandle; pEvent: EventPtr);
  91.                 FORWARD;
  92. FUNCTION TermToolStream(hTerm: TermHandle; pBuffer: CharPtr;
  93.         theBufferSize: Integer): LongInt;
  94.                 FORWARD;
  95. FUNCTION TermToolResize(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  96.                 FORWARD;
  97. FUNCTION TermToolUpdate(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  98.                 FORWARD;
  99. FUNCTION TermToolClick(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  100.                 FORWARD;
  101. FUNCTION TermToolGetSelection(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  102.                 FORWARD;
  103. FUNCTION TermToolSetSelection(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  104.                 FORWARD;
  105. FUNCTION TermToolScroll(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  106.                 FORWARD;
  107. FUNCTION TermToolClear(hTerm: TermHandle): LongInt;
  108.                 FORWARD;
  109. FUNCTION TermToolGetLine(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  110.                 FORWARD;
  111. FUNCTION TermToolPaint(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  112.                 FORWARD;
  113. FUNCTION TermToolCursor(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  114.                 FORWARD;
  115. FUNCTION TermToolGetEnvirons(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  116.                 FORWARD;
  117. FUNCTION TermToolDoTermKey(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  118.                 FORWARD;
  119. FUNCTION TermToolCountTermKeys(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  120.                 FORWARD;
  121. FUNCTION TermToolGetIndTermKey(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  122.                 FORWARD;
  123.  
  124. { end of FORWARD declarations }
  125.  
  126.  
  127.  
  128.  
  129. FUNCTION tdefMAIN(hTerm: TermHandle; msg: Integer; 
  130.         p1, p2, p3: LongInt): LongInt;
  131. BEGIN
  132.     tdefMAIN := 0;        { it helps to be optimistic }
  133.     CASE msg OF            { values of msg here come straight from
  134.                             the interface file values.  Each 
  135.                             must be handled. }
  136.         TMInitMsg:
  137.             tdefMAIN := TermToolInit(hTerm);
  138.         TMDisposeMsg:
  139.             TermToolDispose(hTerm);
  140.         TMSuspendMsg:
  141.             TermToolSuspend(hTerm);
  142.         TMResumeMsg:
  143.             TermToolResume(hTerm);
  144.         TMMenuMsg:
  145.             tdefMAIN := TermToolMenu(hTerm,p1,p2,p3);
  146.         TMEventMsg:
  147.             tdefMAIN := TermToolEvent(hTerm);
  148.         TMActivateMsg:
  149.             TermToolActivate(hTerm);
  150.         TMDeactivateMsg:
  151.             TermToolDeactivate(hTerm);
  152.         TMIdleMsg:
  153.             tdefMAIN := TermToolIdle(hTerm);
  154.         TMResetMsg:
  155.             tdefMAIN := TermToolReset(hTerm);
  156.         TMKeyMsg:
  157.             TermToolKey(hTerm,EventPtr(p1));
  158.         TMStreamMsg:
  159.             tdefMAIN := TermToolStream(hTerm, CharPtr(p1), p2);
  160.         TMResizeMsg:
  161.             tdefMAIN := TermToolReSize(hTerm,p1,p2,p3);
  162.         TMUpdateMsg:
  163.             tdefMAIN := TermToolUpdate(hTerm,p1,p2,p3);
  164.         TMClickMsg:
  165.             tdefMAIN := TermToolClick(hTerm,p1,p2,p3);
  166.         TMGetSelectionMsg:
  167.             tdefMAIN := TermToolGetSelection(hTerm,p1,p2,p3) ;
  168.         TMSetSelectionMsg:
  169.             tdefMAIN := TermToolSetSelection(hTerm,p1,p2,p3);
  170.         TMScrollMsg:
  171.             tdefMAIN := TermToolScroll(hTerm,p1,p2,p3);
  172.         TMClearMsg:
  173.             tdefMAIN := TermToolClear(hTerm);
  174.         TMGetLineMsg:
  175.             tdefMAIN := TermToolGetLine(hTerm,p1,p2,p3);
  176.         TMPaintMsg:
  177.             tdefMAIN := TermToolPaint(hTerm,p1,p2,p3);
  178.         TMCursorMsg:
  179.             tdefMAIN := TermToolCursor(hTerm,p1,p2,p3);
  180.         TMGetEnvironsMsg:
  181.             tdefMAIN := TermToolGetEnvirons(hTerm,p1,p2,p3);
  182.         TMDoTermKeyMsg:
  183.             tdefMAIN := TermToolDoTermKey(hTerm,p1,p2,p3);
  184.         TMCountTermKeysMsg:
  185.             tdefMAIN := TermToolCountTermKeys(hTerm,p1,p2,p3);
  186.         TMGetIndTermKeyMsg:
  187.             tdefMAIN := TermToolGetIndTermKey(hTerm,p1,p2,p3);
  188.     OTHERWISE
  189.         tdefMain := 0;
  190.     END;  { CASE }
  191. END;
  192.  
  193.  
  194. FUNCTION TermToolInit(hTerm: TermHandle): LongInt;
  195. VAR
  196.     StrResID: Integer;
  197.     privatePtr: TERMINALPrivatePtr;
  198.     theProcID: Integer;
  199. BEGIN
  200.     TermToolInit := LongInt(TMNoErr);
  201.     
  202.     { Here we are going to space for our private tool structure, 
  203.         TERMINALPrivateRecord, which I've chosen to declare in my 
  204.         single global unit, TermGlobalUnit.p }
  205.     privatePtr := TERMINALPrivatePtr(NewPtrClear(SIZEOF
  206.         (TERMINALPrivateRecord)));
  207.     IF privatePtr = NIL THEN
  208.         BEGIN
  209.             { Something is goofy with memory allocation, better
  210.                 let everybody know, including the Terminal Mgr, 
  211.                 then exit. }
  212.             hTerm^^.errCode := MemError;
  213.             TermToolInit := LongInt(MemError);
  214.             Exit(TermToolInit);
  215.         END
  216.     ELSE    { so far, so good }
  217.         BEGIN
  218.             theProcID := hTerm^^.procID;    { which tool? }
  219.             StrResID := CRMLocalToRealID(ClassTM, theProcID, 
  220.                 'STR#', verUS);     { let's use the CommResource Mgr 
  221.                     to get the real resource numbers }
  222.             IF (StrResID = -1) THEN
  223.                 BEGIN
  224.                     { Something is goofy with memory allocation, better
  225.                         let everybody know, including the Terminal Mgr, 
  226.                         then exit. }
  227.                     hTerm^^.errCode := MemError;
  228.                     TermToolInit := LongInt(MemError);
  229.                     Exit(TermToolInit);
  230.                 END;
  231.             privatePtr^.currentLanguage := StrResID;
  232.             hTerm^^.tmPrivate := Ptr(privatePtr);
  233.         END;
  234. END;
  235.  
  236.  
  237. PROCEDURE TermToolDispose(hTerm: TermHandle);
  238. BEGIN
  239.     { Standard cleanup of our private data structure.  Since the 
  240.         Terminal manager doesn't really know it's here, we delete it
  241.         ourselves.  The toolbox & application take care of other
  242.         cleanup. }
  243.     DisposPtr(Ptr(hTerm^^.tmPrivate));
  244. END;
  245.  
  246.  
  247.  
  248.  
  249. { Beginning here, until the end of the module, I will repeatedly 
  250. utilize a very simple error checker for each procedure or function. 
  251. Normally a tool would have to perform more useful utility, but 
  252. "at press time" I simply wanted this tool to check the toolbox 
  253. calling conventions.  CSH :)    }
  254.  
  255.  
  256.  
  257. PROCEDURE
  258.     TermToolActivate(hTerm: TermHandle);
  259. VAR
  260.     theState: SignedByte;
  261.     pPrivate: TERMINALPrivatePtr;
  262.     pConfig: TerminalPtr;
  263.     theProcID: Integer;
  264. BEGIN
  265.     theState := HGetState(Handle(hTerm));
  266.     HLock(Handle(hTerm));
  267.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  268.     pConfig := TerminalPtr(hTerm^^.config);
  269.     theProcID := (hTerm^^.procID);
  270.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  271.         DebugStr('The pipe is blocked from TermToolActivate');
  272.     HSetState(Handle(hTerm), theState);
  273. END;
  274.  
  275.  
  276. PROCEDURE
  277.     TermToolDeactivate(hTerm: TermHandle);
  278. VAR
  279.     theState: SignedByte;
  280.     pPrivate: TERMINALPrivatePtr;
  281.     pConfig: TerminalPtr;
  282.     theProcID: Integer;
  283. BEGIN
  284.     theState := HGetState(Handle(hTerm));
  285.     HLock(Handle(hTerm));
  286.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  287.     pConfig := TerminalPtr(hTerm^^.config);
  288.     theProcID := (hTerm^^.procID);
  289.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  290.         DebugStr('The pipe is blocked from TermToolDeactivate');
  291.     HSetState(Handle(hTerm), theState);
  292. END;
  293.  
  294.  
  295. PROCEDURE 
  296.     TermToolSuspend(hTerm: TermHandle);
  297. VAR
  298.     theState: SignedByte;
  299.     pPrivate: TERMINALPrivatePtr;
  300.     pConfig: TerminalPtr;
  301.     theProcID: Integer;
  302. BEGIN
  303.     theState := HGetState(Handle(hTerm));
  304.     HLock(Handle(hTerm));
  305.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  306.     pConfig := TerminalPtr(hTerm^^.config);
  307.     theProcID := (hTerm^^.procID);
  308.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  309.         DebugStr('The pipe is blocked from TermToolSuspend');
  310.     HSetState(Handle(hTerm), theState);
  311. END;
  312.  
  313.  
  314. PROCEDURE 
  315.     TermToolResume(hTerm: TermHandle);
  316. VAR
  317.     theState: SignedByte;
  318.     pPrivate: TERMINALPrivatePtr;
  319.     pConfig: TerminalPtr;
  320.     theProcID: Integer;
  321. BEGIN
  322.     theState := HGetState(Handle(hTerm));
  323.     HLock(Handle(hTerm));
  324.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  325.     pConfig := TerminalPtr(hTerm^^.config);
  326.     theProcID := (hTerm^^.procID);
  327.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  328.         DebugStr('The pipe is blocked from TermToolResume');
  329.     HSetState(Handle(hTerm), theState);
  330. END;
  331.  
  332.  
  333. FUNCTION 
  334.     TermToolMenu(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  335. VAR
  336.     theState: SignedByte;
  337.     pPrivate: TERMINALPrivatePtr;
  338.     pConfig: TerminalPtr;
  339.     theProcID: Integer;
  340. BEGIN
  341.     theState := HGetState(Handle(hTerm));
  342.     HLock(Handle(hTerm));
  343.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  344.     pConfig := TerminalPtr(hTerm^^.config);
  345.     theProcID := (hTerm^^.procID);
  346.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  347.         DebugStr('The pipe is blocked from TermToolMenu');
  348.     HSetState(Handle(hTerm), theState);
  349. END;
  350.  
  351.  
  352. FUNCTION
  353.     TermToolEvent(hTerm: TermHandle): LongInt;
  354. VAR
  355.     theState: SignedByte;
  356.     pPrivate: TERMINALPrivatePtr;
  357.     pConfig: TerminalPtr;
  358.     theProcID: Integer;
  359. BEGIN
  360.     theState := HGetState(Handle(hTerm));
  361.     HLock(Handle(hTerm));
  362.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  363.     pConfig := TerminalPtr(hTerm^^.config);
  364.     theProcID := (hTerm^^.procID);
  365.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  366.         DebugStr('The pipe is blocked from TermToolEvent');
  367.     HSetState(Handle(hTerm), theState);
  368. END;
  369.  
  370.  
  371. FUNCTION
  372.     TermToolIdle(hTerm: TermHandle): LongInt;
  373. VAR
  374.     theState: SignedByte;
  375.     pPrivate: TERMINALPrivatePtr;
  376.     pConfig: TerminalPtr;
  377.     theProcID: Integer;
  378. BEGIN
  379.     theState := HGetState(Handle(hTerm));
  380.     HLock(Handle(hTerm));
  381.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  382.     pConfig := TerminalPtr(hTerm^^.config);
  383.     theProcID := (hTerm^^.procID);
  384.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  385.         DebugStr('The pipe is blocked from TermToolIdle');
  386.     HSetState(Handle(hTerm), theState);
  387. END;
  388.  
  389.  
  390. FUNCTION
  391.     TermToolReset(hTerm: TermHandle): LongInt;
  392. VAR
  393.     theState: SignedByte;
  394.     pPrivate: TERMINALPrivatePtr;
  395.     pConfig: TerminalPtr;
  396.     theProcID: Integer;
  397. BEGIN
  398.     theState := HGetState(Handle(hTerm));
  399.     HLock(Handle(hTerm));
  400.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  401.     pConfig := TerminalPtr(hTerm^^.config);
  402.     theProcID := (hTerm^^.procID);
  403.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  404.         DebugStr('The pipe is blocked from TermToolReset');
  405.     HSetState(Handle(hTerm), theState);
  406. END;
  407.  
  408.  
  409. PROCEDURE TermToolKey(hTerm: TermHandle; pEvent: EventPtr);
  410. VAR
  411.     theState: SignedByte;
  412.     pPrivate: TERMINALPrivatePtr;
  413.     pConfig: TerminalPtr;
  414.     theProcID: Integer;
  415. BEGIN
  416.     theState := HGetState(Handle(hTerm));
  417.     HLock(Handle(hTerm));
  418.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  419.     pConfig := TerminalPtr(hTerm^^.config);
  420.     theProcID := (hTerm^^.procID);
  421.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  422.         DebugStr('The pipe is blocked from TermToolKey');
  423.     HSetState(Handle(hTerm), theState);
  424. END;
  425.  
  426.  
  427. FUNCTION
  428.     TermToolStream(hTerm: TermHandle; pBuffer: CharPtr;
  429.         theBufferSize: Integer): LongInt;
  430. VAR
  431.     theState: SignedByte;
  432.     pPrivate: TERMINALPrivatePtr;
  433.     pConfig: TerminalPtr;
  434.     theProcID: Integer;
  435. BEGIN
  436.     theState := HGetState(Handle(hTerm));
  437.     HLock(Handle(hTerm));
  438.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  439.     pConfig := TerminalPtr(hTerm^^.config);
  440.     theProcID := (hTerm^^.procID);
  441.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  442.         DebugStr('The pipe is blocked from TermToolStream');
  443.     HSetState(Handle(hTerm), theState);
  444. END;
  445.  
  446.  
  447. FUNCTION
  448.     TermToolReSize(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  449. VAR
  450.     theState: SignedByte;
  451.     pPrivate: TERMINALPrivatePtr;
  452.     pConfig: TerminalPtr;
  453.     theProcID: Integer;
  454. BEGIN
  455.     theState := HGetState(Handle(hTerm));
  456.     HLock(Handle(hTerm));
  457.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  458.     pConfig := TerminalPtr(hTerm^^.config);
  459.     theProcID := (hTerm^^.procID);
  460.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  461.         DebugStr('The pipe is blocked from TermToolReSize');
  462.     HSetState(Handle(hTerm), theState);
  463. END;
  464.  
  465.  
  466. FUNCTION
  467.     TermToolUpdate(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  468. VAR
  469.     theState: SignedByte;
  470.     pPrivate: TERMINALPrivatePtr;
  471.     pConfig: TerminalPtr;
  472.     theProcID: Integer;
  473. BEGIN
  474.     theState := HGetState(Handle(hTerm));
  475.     HLock(Handle(hTerm));
  476.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  477.     pConfig := TerminalPtr(hTerm^^.config);
  478.     theProcID := (hTerm^^.procID);
  479.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  480.         DebugStr('The pipe is blocked from TermToolUpdate');
  481.     HSetState(Handle(hTerm), theState);
  482. END;
  483.  
  484.  
  485. FUNCTION
  486.     TermToolClick(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  487. VAR
  488.     theState: SignedByte;
  489.     pPrivate: TERMINALPrivatePtr;
  490.     pConfig: TerminalPtr;
  491.     theProcID: Integer;
  492. BEGIN
  493.     theState := HGetState(Handle(hTerm));
  494.     HLock(Handle(hTerm));
  495.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  496.     pConfig := TerminalPtr(hTerm^^.config);
  497.     theProcID := (hTerm^^.procID);
  498.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  499.         DebugStr('The pipe is blocked from TermToolClick');
  500.     HSetState(Handle(hTerm), theState);
  501. END;
  502.  
  503.  
  504. FUNCTION
  505.     TermToolGetSelection(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  506. VAR
  507.     theState: SignedByte;
  508.     pPrivate: TERMINALPrivatePtr;
  509.     pConfig: TerminalPtr;
  510.     theProcID: Integer;
  511. BEGIN
  512.     theState := HGetState(Handle(hTerm));
  513.     HLock(Handle(hTerm));
  514.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  515.     pConfig := TerminalPtr(hTerm^^.config);
  516.     theProcID := (hTerm^^.procID);
  517.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  518.         DebugStr('The pipe is blocked from TermToolGetSelection');
  519.     HSetState(Handle(hTerm), theState);
  520. END;
  521.  
  522.  
  523. FUNCTION
  524.     TermToolSetSelection(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  525. VAR
  526.     theState: SignedByte;
  527.     pPrivate: TERMINALPrivatePtr;
  528.     pConfig: TerminalPtr;
  529.     theProcID: Integer;
  530. BEGIN
  531.     theState := HGetState(Handle(hTerm));
  532.     HLock(Handle(hTerm));
  533.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  534.     pConfig := TerminalPtr(hTerm^^.config);
  535.     theProcID := (hTerm^^.procID);
  536.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  537.         DebugStr('The pipe is blocked from TermToolSetSelection');
  538.     HSetState(Handle(hTerm), theState);
  539. END;
  540.  
  541.  
  542. FUNCTION
  543.     TermToolScroll(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  544. VAR
  545.     theState: SignedByte;
  546.     pPrivate: TERMINALPrivatePtr;
  547.     pConfig: TerminalPtr;
  548.     theProcID: Integer;
  549. BEGIN
  550.     theState := HGetState(Handle(hTerm));
  551.     HLock(Handle(hTerm));
  552.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  553.     pConfig := TerminalPtr(hTerm^^.config);
  554.     theProcID := (hTerm^^.procID);
  555.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  556.         DebugStr('The pipe is blocked from TermToolScroll');
  557.     HSetState(Handle(hTerm), theState);
  558. END;
  559.  
  560.  
  561. FUNCTION
  562.     TermToolClear(hTerm: TermHandle): LongInt;
  563. VAR
  564.     theState: SignedByte;
  565.     pPrivate: TERMINALPrivatePtr;
  566.     pConfig: TerminalPtr;
  567.     theProcID: Integer;
  568. BEGIN
  569.     theState := HGetState(Handle(hTerm));
  570.     HLock(Handle(hTerm));
  571.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  572.     pConfig := TerminalPtr(hTerm^^.config);
  573.     theProcID := (hTerm^^.procID);
  574.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  575.         DebugStr('The pipe is blocked from TermToolClear');
  576.     HSetState(Handle(hTerm), theState);
  577. END;
  578.  
  579.  
  580. FUNCTION
  581.     TermToolGetLine(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  582. VAR
  583.     theState: SignedByte;
  584.     pPrivate: TERMINALPrivatePtr;
  585.     pConfig: TerminalPtr;
  586.     theProcID: Integer;
  587. BEGIN
  588.     theState := HGetState(Handle(hTerm));
  589.     HLock(Handle(hTerm));
  590.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  591.     pConfig := TerminalPtr(hTerm^^.config);
  592.     theProcID := (hTerm^^.procID);
  593.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  594.         DebugStr('The pipe is blocked from TermToolGetLine');
  595.     HSetState(Handle(hTerm), theState);
  596. END;
  597.  
  598.  
  599. FUNCTION
  600.     TermToolPaint(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  601. VAR
  602.     theState: SignedByte;
  603.     pPrivate: TERMINALPrivatePtr;
  604.     pConfig: TerminalPtr;
  605.     theProcID: Integer;
  606. BEGIN
  607.     theState := HGetState(Handle(hTerm));
  608.     HLock(Handle(hTerm));
  609.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  610.     pConfig := TerminalPtr(hTerm^^.config);
  611.     theProcID := (hTerm^^.procID);
  612.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  613.         DebugStr('The pipe is blocked from TermToolPaint');
  614.     HSetState(Handle(hTerm), theState);
  615. END;
  616.  
  617.  
  618. FUNCTION
  619.     TermToolCursor(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  620. VAR
  621.     theState: SignedByte;
  622.     pPrivate: TERMINALPrivatePtr;
  623.     pConfig: TerminalPtr;
  624.     theProcID: Integer;
  625. BEGIN
  626.     theState := HGetState(Handle(hTerm));
  627.     HLock(Handle(hTerm));
  628.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  629.     pConfig := TerminalPtr(hTerm^^.config);
  630.     theProcID := (hTerm^^.procID);
  631.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  632.         DebugStr('The pipe is blocked from TermToolCursor');
  633.     HSetState(Handle(hTerm), theState);
  634. END;
  635.  
  636.  
  637. FUNCTION
  638.     TermToolGetEnvirons(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  639. VAR
  640.     theState: SignedByte;
  641.     pPrivate: TERMINALPrivatePtr;
  642.     pConfig: TerminalPtr;
  643.     theProcID: Integer;
  644. BEGIN
  645.     theState := HGetState(Handle(hTerm));
  646.     HLock(Handle(hTerm));
  647.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  648.     pConfig := TerminalPtr(hTerm^^.config);
  649.     theProcID := (hTerm^^.procID);
  650.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  651.         DebugStr('The pipe is blocked from TermToolGetEnvirons');
  652.     HSetState(Handle(hTerm), theState);
  653. END;
  654.  
  655.  
  656. FUNCTION
  657.     TermToolDoTermKey(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  658. VAR
  659.     theState: SignedByte;
  660.     pPrivate: TERMINALPrivatePtr;
  661.     pConfig: TerminalPtr;
  662.     theProcID: Integer;
  663. BEGIN
  664.     theState := HGetState(Handle(hTerm));
  665.     HLock(Handle(hTerm));
  666.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  667.     pConfig := TerminalPtr(hTerm^^.config);
  668.     theProcID := (hTerm^^.procID);
  669.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  670.         DebugStr('The pipe is blocked from TermToolDoTermKey');
  671.     HSetState(Handle(hTerm), theState);
  672. END;
  673.  
  674.  
  675. FUNCTION
  676.     TermToolCountTermKeys(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  677. VAR
  678.     theState: SignedByte;
  679.     pPrivate: TERMINALPrivatePtr;
  680.     pConfig: TerminalPtr;
  681.     theProcID: Integer;
  682. BEGIN
  683.     theState := HGetState(Handle(hTerm));
  684.     HLock(Handle(hTerm));
  685.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  686.     pConfig := TerminalPtr(hTerm^^.config);
  687.     theProcID := (hTerm^^.procID);
  688.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  689.         DebugStr('The pipe is blocked from TermToolCountTermKeys');
  690.     HSetState(Handle(hTerm), theState);
  691. END;
  692.  
  693.  
  694. FUNCTION 
  695.     TermToolGetIndTermKey(hTerm: TermHandle; p1, p2, p3: LongInt): LongInt;
  696. VAR
  697.     theState: SignedByte;
  698.     pPrivate: TERMINALPrivatePtr;
  699.     pConfig: TerminalPtr;
  700.     theProcID: Integer;
  701. BEGIN
  702.     theState := HGetState(Handle(hTerm));
  703.     HLock(Handle(hTerm));
  704.     pPrivate := TERMINALPrivatePtr(hTerm^^.tmPrivate);
  705.     pConfig := TerminalPtr(hTerm^^.config);
  706.     theProcID := (hTerm^^.procID);
  707.     IF (theProcID < 3) OR (pConfig = NIL) OR (pPrivate = NIL) THEN
  708.         DebugStr('The pipe is blocked from TermToolGetIndTermKey');
  709.     HSetState(Handle(hTerm), theState);
  710. END;
  711.  
  712.  
  713.  
  714.  
  715.  
  716.  
  717. END.